package com.htd.htdapmcommon.util;


import com.htd.htdapmcommon.constants.CommonConstants;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtil {

    public static boolean isNotNull(String s) {
        return (null != s) && (s.trim().length() != 0);
    }

    public static boolean isNull(String s) {
        return (null == s) || (s.trim().length() == 0);
    }

    public static boolean isNum(String str) {
        Pattern pattern = Pattern.compile("[0-9]*");
        return pattern.matcher(str).matches();
    }

    public static String leftFillZero(String s, int length) {
        if ((null == s) || ("".equals(s.trim())) || (length <= 0)) {
            return "";
        }
        s = s.trim();
        if (s.length() == length) {
            return s;
        }
        int i = 0;
        StringBuilder sb = new StringBuilder();
        while (i < length) {
            sb.append("0");
            i++;
        }
        sb.append(s);
        return sb.substring(sb.length() - length);
    }

    public static String rightFillSpace(String s, int length) {
        int fillLength = 0;
        if (s != null) {
            if (s.trim().length() > length) {
                return s.trim().substring(0, length);
            }
            fillLength = length - s.trim().length();
        } else {
            fillLength = length;
        }
        StringBuilder sb = new StringBuilder();
        if (s != null)
            sb.append(s.trim());
        for (int i = 0; i < fillLength; i++) {
            sb.append(" ");
        }
        if (sb.length() > length) {
            return sb.substring(0, length);
        }
        return sb.toString();
    }

    public static String replaceBlack(String data) {
        if (isNotNull(data)) {
            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
            Matcher m = p.matcher(data);
            data = m.replaceAll("");
        }
        return data;
    }

    /**
     * 格式化钱（如：2000L--20.00）
     * 
     * @param money
     * @return
     */
    public static String formatMoney(Long money) {
        if (money == null || "".equals(String.valueOf(money).trim())) {
            return "0.00";
        }
        String m = money.toString();
        int len = m.trim().length();
        String result = "";
        switch (len) {
            case 1:
                result = "0.0" + m;
                break;
            case 2:
                result = "0." + m;
                break;
            default:
                result = m.substring(0, m.length() - 2) + "." + m.substring(m.length() - 2);
                break;
        }
        return result;
    }

    /**
     * 去除字符串中的空格,换行,制表符
     * 
     * @param s
     * @return
     */
    public static String trim(String s) {
        Pattern p = Pattern.compile("\\s*|\t|\r|\n");
        Matcher m = p.matcher(s);
        String after = m.replaceAll("");
        return after;
    }

    /**
     * 将string 格式的钱转换为long（如："20.00"--2000L） 输入格式必须为"20.00"
     * 
     * @param money
     * @return
     */
    public static Long moneyToLong(String money) {
        if (money == null)
            return null;
        money = money.trim();
        if (money.indexOf(".") > 0) {
            int index = money.indexOf(".");
            int len = money.length();
            if (len - index >= 3) {
                money = money.substring(0, index) + money.substring(index + 1, index + 3);
            } else if (len - index == 2) {
                money = money.substring(0, index) + money.substring(index + 1) + "0";
            } else {
                money = money.substring(0, index) + "00";
            }
        } else {
            money = money + "00";
        }
        return Long.valueOf(money);
    }

    public static String get2PointFromStr(Long value) {

        String twoPointStr = String.valueOf(value / 100D);
        String[] valAndPoint = twoPointStr.split("\\.");
        String pointVal = valAndPoint[1];
        if (pointVal == null) {
            twoPointStr += ".00";
        } else if (1 == pointVal.length()) {
            twoPointStr += "0";
        }
        return twoPointStr;
    }

    /**
     * 
     * 获取字符串的长度，如果有中文，则每个中文字符计为2位
     * 
     * @param value 指定的字符串
     * @return 字符串的长度
     */
    public static int length(String value) {
        int valueLength = 0;
        String chinese = "[\u0391-\uFFE5]";
        /* 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1 */
        for (int i = 0; i < value.length(); i++) {
            /* 获取一个字符 */
            String temp = value.substring(i, i + 1);
            /* 判断是否为中文字符 */
            if (temp.matches(chinese)) {
                /* 中文字符长度为2 */
                valueLength += 2;
            } else {
                /* 其他字符长度为1 */
                valueLength += 1;
            }
        }
        return valueLength;

    }

    /**
     * 判断字符长度是否超长
     * 
     * @param str
     * @param maxLength
     * @return
     */
    public static boolean isTooLong(String str, int maxLength) {
        return str.length() > maxLength;
    }

    /**
     * 判断是否是金额字段
     * 
     * @param str
     * @return
     */
    public static boolean isMoney(String str) {
        Pattern pattern = Pattern.compile("[1-9]\\d*");
        return pattern.matcher(str).matches();

    }

    /**
     * 判断是否是日期格式
     * 
     * @param dateStr
     * @return
     */
    public static boolean isDateStr(String dateStr) {
        try {
            new Date(new SimpleDateFormat(CommonConstants.DATEFORMATE_YYYYMMDDHHMMSS).parse(dateStr).getTime());
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 转化为Date
     * 
     * @param dateStr
     * @return
     */
    public static Date parseStr2Date(String dateStr) {
        Date date = null;
        try {
            date = new Date(new SimpleDateFormat(CommonConstants.DATEFORMATE_YYYYMMDDHHMMSS).parse(dateStr).getTime());
        } catch (Exception e) {
        }
        return date;
    }

    /**
     * 
     * 功能描述:字符串空值校验 <br>
     * 传入的字符串，只要有一个为null或者为空返回true，否则返回false
     * 
     * @param strs ：可变字符串数组，可以同时传入多个字符串参数
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static boolean isAnyNullOrEmpty(String... strs) {
        for (String str : strs) {
            if (str == null || str.trim().length() == 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 
     * 功能描述: <br>
     * 〈将转码后的特殊字符转化回原字符〉
     * 
     * @param encodeSpecialChar
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String revertEncodeSpecialChar(String encodeSpecialChar) {
        // 分号|小于号|大于号|单引号
        String result = encodeSpecialChar.replaceAll("&#46;", ";");
        result = result.replaceAll("&#60;", "<");
        result = result.replaceAll("&#62;", ">");
        result = result.replaceAll("&#39;", "'");

        return result;
    }

    /**
     * 
     * 功能描述: <br>
     * 〈将转码后的特殊字符转化回原字符〉
     * 
     * @param encodeSpecialChar
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String revertEncodeSpaceChar(String encodeSpecialChar) {
        // 空格
        String result = encodeSpecialChar.replaceAll("%20", " ");

        return result;
    }

    /**
     * 功能描述: <br>
     * 〈账户隐位〉
     * 
     * @param userName
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String getHiddenAccount(String userName) {
        String userAlias = null;
        if (StringUtil.isNotNull(userName)) {
            int len = userName.indexOf("@");

            if (len < 0) {

                // 手机登陆
                userAlias = userName.substring(0, 3) + "****" + userName.substring(userName.length() - 4);

            } else {
                // 邮箱登陆
                if (len > 1) {
                    userAlias = userName.substring(0, 2) + "***" + userName.substring(len - 1);
                } else {
                    userAlias = userName.substring(0, 1) + userName.substring(0, 1) + "***" + userName.substring(0);
                }
            }
        }
        return userAlias;
    }

    /**
     * 
     * 功能描述: <br>
     * 〈手机号隐位〉
     * 
     * @param phone
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String hiddenPhone(String phone) {
        if (StringUtil.isNotNull(phone) && phone.length() > 3) {
            phone = phone.substring(0, 3) + "******" + phone.substring(phone.length() - 2, phone.length());
        }
        return phone;
    }

    /**
     * 功能描述: <br>
     * 〈银行卡隐位〉
     * 
     * @param bankNo
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String hiddenBankNo(String bankNo) {
        if (StringUtil.isNotNull(bankNo) && bankNo.length() > 4) {
            bankNo = "**" + bankNo.substring(bankNo.length() - 4);
        }
        return bankNo;
    }

    /**
     * 功能描述: <br>
     * 〈姓名隐位〉
     * 
     * @param userName
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String hiddenUserName(String userName) {
        if (StringUtil.isNotNull(userName) && userName.length() > 1) {
            userName = "*" + userName.substring(1, userName.length());
        }
        return userName;
    }

    /**
     * 功能描述: <br>
     * 〈身份证隐位〉
     * 
     * @param idNo
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String hiddenIdNo(String idNo) {
        if (StringUtil.isNotNull(idNo) && idNo.length() > 1) {
            idNo = idNo.substring(0, 1) + "***************" + idNo.substring(idNo.length() - 1, idNo.length());
        }
        return idNo;
    }

    /**
     * 功能描述: <br>
     * 〈短字符串隐位，隐藏后4位〉
     * 
     * @param bankNo
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static String hiddenShort(String str) {
        if (StringUtil.isNotNull(str)) {
            str = str.substring(0, str.length() - 4) + "****";
        }
        return str;
    }

    public static String getSafeString(String s) {
        String str = null;
        if (StringUtil.isNotNull(s)) {
            str = s.replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("'", "&#x27;")
                    .replaceAll("\"", "&quot;").replaceAll("&", "&amp;").replaceAll("`", "&#x60;");
        }
        return str;
    }

    /**
     * 转换单位
     */
    private static final int COUNT_HUNDRED = 100;

    /**
     * 
     * 功能描述: <br>
     * 分->元
     * 
     * @param fenMoney
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static BigDecimal fenMoneyToYuan(BigDecimal fenMoney) {
        BigDecimal newMoney = null;
        if (fenMoney == null) {
            newMoney = null;
        } else {
            newMoney = fenMoney.divide(new BigDecimal(COUNT_HUNDRED));
        }
        return newMoney;
    }
    
    /**
     * 元转为分
     * 
     * @param yuan
     * @return
     */
    public static BigDecimal yuanToFen(BigDecimal yuan) {
        BigDecimal newMoney = null;
        if (yuan == null) {
            newMoney = null;
        } else {
            newMoney = yuan.multiply(new BigDecimal(COUNT_HUNDRED));
        }
        return newMoney;
    }
    
	/**
	 * 对于金额保留指定位数小数
	 * 
	 * @param dec
	 * @return
	 */
	public static BigDecimal getDecimalScale(BigDecimal dec, int scale) {
		BigDecimal retDec = BigDecimal.ZERO;
		retDec = dec;
		if (retDec == null) {
			retDec = new BigDecimal("0.00000000000");
		}
		retDec = retDec.setScale(scale, RoundingMode.HALF_UP);
		return retDec;
	}
	
	/**
	 * 对于金额不保留小数位数输出
	 * 
	 * @param dec
	 * @return
	 */
	public static BigDecimal getDecimalScale0(BigDecimal dec) {
		return getDecimalScale(dec, 0);
	}
	
	/**
	 * 对于输入的数据format成不含小数部分的格式
	 * 
	 * @param dec
	 * @return
	 */
	public static String formatBigDecimalWithoutFractional(BigDecimal dec) {
		BigDecimal tmpDec = getDecimalScale0(dec);
		DecimalFormat df = new DecimalFormat("#,###");
		String decimalStr = df.format(tmpDec).equals("0") ? "0" : df
				.format(tmpDec);
		if (decimalStr.startsWith(".")) {
			decimalStr = "0" + decimalStr;
		}
		return decimalStr;
	}
	
	public static String formatCommaAnd2Point(BigDecimal dec) {
		BigDecimal tmpDec = getDecimalScale2(dec);
		DecimalFormat df = new DecimalFormat("#,###.00");
		String decimalStr = df.format(tmpDec).equals(".00") ? "0.00" : df
				.format(tmpDec);
		if (decimalStr.startsWith(".")) {
			decimalStr = "0" + decimalStr;
		}
		return decimalStr;
	}
	
	/**
	 * 对于金额保留2位小数输出
	 * 
	 * @param dec
	 * @return
	 */
	public static BigDecimal getDecimalScale2(BigDecimal dec) {
		return getDecimalScale(dec, 2);
	}
	
	public static void main(String[] arg) throws Exception {
	}
	
	/**
	 * 如果参数的字符串为空（NULL 或者 empty），返回一个空格的字符串
	 * @param str
	 * @return
	 */
	public static String empty2OneSpace(String str) {
		if (isNull(str)) {
			return " ";
		}
		
		return str;
	}
	
	/**
	 * 把数字转成非科学记数法形式的字符串
	 * @param number
	 * @return 转换后的非科学记数法的字符串 
	 */
	public static String bigDecimal2PlainString(BigDecimal number) {
		if (number == null) {
			return "";
		}
		
		return number.setScale(2, BigDecimal.ROUND_HALF_DOWN).toPlainString();
	}
}